home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / share / hal / device-manager / DeviceManager.py < prev    next >
Encoding:
Python Source  |  2007-05-11  |  20.5 KB  |  512 lines
  1. """This file contains the DeviceManager class."""
  2.  
  3. import LaunchpadIntegration
  4. import sys
  5. import gobject
  6. import gtk
  7. import dbus
  8. if getattr(dbus, "version", (0,0,0)) >= (0,41,0):
  9.     import dbus.glib
  10.  
  11.  
  12.  
  13. try:
  14.     import gnome.ui
  15.  
  16. except ImportError:
  17.     gnome_imported = 0
  18. else:
  19.     gnome_imported = 1
  20.  
  21. import Const
  22. from Representation import Representation
  23. from Device import Device
  24.  
  25. from LibGladeApplication import LibGladeApplication
  26.  
  27. class DeviceManager(LibGladeApplication):
  28.     """This is the main window for the application."""
  29.  
  30.  
  31.     def on_about_activate(self, w):
  32.         """Show the about dialog."""
  33.         try:
  34.             self.about.destroy()
  35.         finally:
  36.             self.about = gnome.ui.About(Const.NAME_LONG, Const.VERSION, Const.COPYRIGHT,
  37.                                         Const.INFO, Const.AUTHORS).show()
  38.             self.about.show()
  39.  
  40.     def on_virtual_devices_activate(self, obj):
  41.         self.dont_show_virtual = 1 - self.dont_show_virtual
  42.         self.update_device_list()
  43.  
  44.     def __init__(self):
  45.         """Init the GUI and connect to the HAL daemon."""
  46.         LibGladeApplication.__init__(self, Const.DATADIR + "/hal-device-manager.glade")
  47.  
  48.         LaunchpadIntegration.set_sourcepackagename("hal")
  49.     widget = self.xml.get_widget("help1_menu")
  50.     print widget
  51.         LaunchpadIntegration.add_items (widget, -1, False, True);
  52.  
  53.         ver = getattr(dbus, 'version', (0, 0, 0))
  54.         if ver < (0, 40, 0):
  55.             dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, 
  56.                                        gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE,
  57.                                        "The DBus Python Bindings you are using are too old. "
  58.                                        "Make sure you have the latest version!")
  59.             dialog.run()
  60.             sys.exit(1)
  61.  
  62.         if not gnome_imported:
  63.             self.xml.get_widget("about1").set_sensitive(0)
  64.  
  65.         self.representation = Representation()
  66.  
  67.         self.bus = dbus.SystemBus()
  68.         self.hal_manager_obj = self.bus.get_object("org.freedesktop.Hal", 
  69.                                                    "/org/freedesktop/Hal/Manager")
  70.         self.hal_manager = dbus.Interface(self.hal_manager_obj,
  71.                                           "org.freedesktop.Hal.Manager")
  72.  
  73.         # gdl_changed will be invoked when the Global Device List is changed
  74.         # per the hal spec
  75.         self.hal_manager.connect_to_signal("DeviceAdded", 
  76.                          lambda *args: self.gdl_changed("DeviceAdded", *args))
  77.         self.hal_manager.connect_to_signal("DeviceRemoved", 
  78.                          lambda *args: self.gdl_changed("DeviceRemoved", *args))
  79.         self.hal_manager.connect_to_signal("NewCapability", 
  80.                          lambda *args: self.gdl_changed("NewCapability", *args))
  81.  
  82.         # Add listeners for all devices
  83.         try:
  84.             device_names = self.hal_manager.GetAllDevices()
  85.         except:
  86.             dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, 
  87.                                        gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE,
  88.                                        "Could not get device list. "
  89.                                        "Make sure hald is running!")
  90.             dialog.run()
  91.             sys.exit(1)
  92.  
  93.         for name in device_names:
  94.         self.add_device_signal_recv (name);
  95.  
  96.         self.dont_show_virtual = 1
  97.         self.update_device_list()
  98.         self.main_window.show()
  99.  
  100.     def add_device_signal_recv (self, udi):
  101.     self.bus.add_signal_receiver(lambda *args: self.property_modified(udi, *args),
  102.                      "PropertyModified",
  103.                      "org.freedesktop.Hal.Device",
  104.                      "org.freedesktop.Hal",
  105.                      udi)
  106.  
  107.     def remove_device_signal_recv (self, udi):
  108.         try:
  109.             self.bus.remove_signal_receiver(None,
  110.                             "PropertyModified",
  111.                             "org.freedesktop.Hal.Device",
  112.                             "org.freedesktop.Hal",
  113.                             udi)
  114.         except Exception, e:
  115.             print "Older versions of the D-BUS bindings have an error when removing signals. Please upgrade."
  116.             print e
  117.  
  118.     def get_current_focus_udi(self):
  119.         """Get the UDI of the currently focused device"""
  120.         (tree_model, tree_iter) = self.tree_selection.get_selected()
  121.         if tree_iter:
  122.             device_udi = tree_model.get_value(tree_iter, Const.UDI_COLUMN)
  123.             return device_udi
  124.         return None
  125.  
  126.     def on_device_tree_selection_changed(self, tree_selection):
  127.         """This method is called when the selection has changed in the
  128.         device tree"""
  129.         device_udi = self.get_current_focus_udi()
  130.         if device_udi != None:
  131.             device = self.udi_to_device(device_udi)
  132.             self.update_device_notebook(device)
  133.  
  134.  
  135.     def device_condition(self, device_udi, condition_name, condition_details):
  136.         """This method is called when signals on the Device interface is
  137.         received"""
  138.  
  139.     print "\nCondition device=%s"%device_udi
  140.     print "  (condition_name, condition_details) = ('%s', '%s')"%(condition_name, condition_details)
  141.  
  142.     def property_modified(self, device_udi, num_changes, change_list):
  143.         """This method is called when signals on the Device interface is
  144.         received"""
  145.  
  146.     print "\nPropertyModified, device=%s"%device_udi
  147.     for i in change_list:
  148.         property_name = i[0]
  149.         removed = i[1]
  150.         added = i[2]
  151.  
  152.         print "  key=%s, rem=%d, add=%d"%(property_name, removed, added)
  153.         if property_name=="info.parent":
  154.         self.update_device_list()        
  155.         else:
  156.         device_udi_obj = self.bus.get_object("org.freedesktop.Hal", device_udi)
  157.         device_obj = self.udi_to_device(device_udi)
  158.  
  159.         if device_udi_obj.PropertyExists(property_name, dbus_interface="org.freedesktop.Hal.Device"):
  160.             device_obj.properties[property_name] = device_udi_obj.GetProperty(property_name, 
  161.                                               dbus_interface="org.freedesktop.Hal.Device")
  162.             print "  value=%s"%(device_obj.properties[property_name])
  163.         else:
  164.             if device_obj != None:
  165.             try:
  166.                 del device_obj.properties[property_name]
  167.             except:
  168.                 pass
  169.  
  170.         device_focus_udi = self.get_current_focus_udi()
  171.         if device_focus_udi != None:
  172.             device = self.udi_to_device(device_udi)
  173.             if device_focus_udi==device_udi:
  174.             self.update_device_notebook(device)
  175.             
  176.     def gdl_changed(self, signal_name, device_udi, *args):
  177.         """This method is called when a HAL device is added or removed."""
  178.  
  179.         if signal_name=="DeviceAdded":
  180.             print "\nDeviceAdded, udi=%s"%(device_udi)
  181.         self.add_device_signal_recv (device_udi)
  182.             self.update_device_list()
  183.         elif signal_name=="DeviceRemoved":
  184.             print "\nDeviceRemoved, udi=%s"%(device_udi)
  185.         self.remove_device_signal_recv (device_udi)
  186.             self.update_device_list()
  187.         elif signal_name=="NewCapability":
  188.             [cap] = args 
  189.             print "\nNewCapability, cap=%s, udi=%s"%(cap, device_udi)
  190.         else:
  191.             print "*** Unknown signal %s"% signal_name
  192.  
  193.  
  194.     def update_device_list(self):
  195.         """Builds, or rebuilds, the device tree"""
  196.         # We use a virtual root device so we have a single tree
  197.         self.virtual_root = self.build_device_tree()
  198.  
  199.         # (Name to display, device UDI)
  200.         try:
  201.             if self.tree_model:
  202.                 pass
  203.         except:
  204.             self.tree_model = gtk.TreeStore(gtk.gdk.Pixbuf,
  205.                                             gobject.TYPE_STRING, gobject.TYPE_STRING)
  206.         while 1:
  207.             it = self.tree_model.get_iter_first()
  208.             if not it:
  209.                 break
  210.             self.tree_model.remove(it)
  211.  
  212.         self.virtual_root.populate_gtk_tree(self.tree_model,
  213.                                             self.dont_show_virtual,
  214.                                             self.representation)
  215.  
  216.         tree_view = self.xml.get_widget("device_tree")
  217.         try:
  218.             if self.tree_selection:
  219.                 pass
  220.         except:
  221.             self.tree_selection = tree_view.get_selection()
  222.             self.tree_selection.connect("changed",
  223.                                         self.on_device_tree_selection_changed)
  224.  
  225.         # add new columns only first time
  226.         try:
  227.             if self.column_dt:
  228.                 pass
  229.         except:
  230.             self.column_dt = gtk.TreeViewColumn()
  231.             self.column_dt.set_title("Devices")
  232.             render_pixbuf = gtk.CellRendererPixbuf()
  233.             self.column_dt.pack_start(render_pixbuf, expand=False)
  234.             self.column_dt.add_attribute(render_pixbuf, "pixbuf",
  235.                                          Const.PIXBUF_COLUMN)
  236.             render_text = gtk.CellRendererText()
  237.             self.column_dt.pack_start(render_text, expand=True)
  238.             self.column_dt.add_attribute(render_text, "text",
  239.                                          Const.TITLE_COLUMN)
  240.             tree_view.append_column(self.column_dt)
  241.  
  242.         tree_view.set_model(self.tree_model)
  243.         tree_view.expand_all()
  244.  
  245.         # Set focus to first element
  246.         tree_view.grab_focus()
  247.         self.update_device_notebook(self.virtual_root.children[0])
  248.  
  249.  
  250.     def udi_to_device(self, device_udi):
  251.         """Given a HAL UDI (Unique Device Identifier) this method returns
  252.         the corresponding HAL device"""
  253.         return self.virtual_root.find_by_udi(device_udi)
  254.  
  255.     def build_device_tree(self):
  256.         """Retrieves the device list from the HAL daemon and builds
  257.         a tree of Device (Python) objects. The root is a virtual
  258.         device"""
  259.         device_names = self.hal_manager.GetAllDevices()
  260.         device_names.sort()
  261.  
  262.         virtual_root = Device("virtual_root", None, {})
  263.         self.device_list = [virtual_root]
  264.         
  265.         # first build list of Device objects
  266.         for name in device_names:
  267.             device_dbus_obj = self.bus.get_object("org.freedesktop.Hal" ,name)
  268.             properties = device_dbus_obj.GetAllProperties(dbus_interface="org.freedesktop.Hal.Device")
  269.             try:
  270.                 parent_name = properties["info.parent"]
  271.             except KeyError:
  272.                 # no parent, must be parent of virtual_root
  273.                 parent_name = "/"
  274.             except TypeError:
  275.                 print "Error: no properties for device %s"%name
  276.                 continue
  277.             device = Device(name, parent_name, properties)
  278.             self.device_list.append(device)
  279.  
  280.         # set parent_device and children for each Device object
  281.         for device in self.device_list:
  282.             parent_name = device.parent_name
  283.             device.parent_device = virtual_root
  284.             if parent_name!="/":
  285.                 for p in self.device_list:
  286.                     if p.device_name==parent_name:
  287.                         device.parent_device = p
  288.                         p.children.append(device)
  289.             if device!=virtual_root and device.parent_device==virtual_root:
  290.                 virtual_root.children.append(device)
  291.             if device==virtual_root:
  292.                 device.parent_device=None
  293.         return virtual_root
  294.  
  295.  
  296.     def update_tab_device(self, device):
  297.         """Updates the 'Device' tab given a Device object"""
  298.         bus = self.xml.get_widget("ns_device_bus")
  299.         #state = self.xml.get_widget("ns_device_status")
  300.         vendor = self.xml.get_widget("ns_device_vendor")
  301.         product = self.xml.get_widget("ns_device_name")
  302.         category = self.xml.get_widget("ns_device_category")
  303.         capabilities = self.xml.get_widget("ns_device_capabilities")
  304.  
  305.         product.set_label("Unknown")
  306.         vendor.set_label("Unknown")
  307.         #state.set_label(Const.STATE_NAMES[device.properties["State"]])
  308.  
  309.         # walk up the device tree to find the bus type
  310.         bus.set_label("Unknown")
  311.         d = device
  312.         while d:
  313.             if d.properties.has_key("info.subsystem"):
  314.                 bus.set_label(Const.BUS_NAMES[d.properties["info.subsystem"]])
  315.                 break
  316.             d = self.udi_to_device(d.properties["info.parent"])
  317.  
  318.         # guestimate product and vendor if we have no device information file
  319.         if device.properties.has_key("info.subsystem") and device.properties["info.subsystem"]=="usb":
  320.             if device.properties.has_key("info.product"):
  321.                 product.set_label("%s"%device.properties["info.product"])
  322.             elif device.properties.has_key("usb.product"):
  323.                 product.set_label("%s"%device.properties["usb.product"])
  324.             elif device.properties.has_key("usb.product_id"):
  325.                 product.set_label("Unknown (0x%x)"%device.properties["usb.product_id"])
  326.             else:
  327.                 product.set_label("Unknown")
  328.  
  329.             if device.properties.has_key("info.vendor"):
  330.                 vendor.set_label("%s"%device.properties["info.vendor"])
  331.             elif device.properties.has_key("usb.vendor"):
  332.                 vendor.set_label("%s"%device.properties["usb.vendor"])
  333.             elif device.properties.has_key("usb.vendor_id"):
  334.                 vendor.set_label("Unknown (0x%x)"%device.properties["usb.vendor_id"])
  335.             else:
  336.                 vendor.set_label("Unknown")
  337.  
  338.  
  339.         elif device.properties.has_key("info.subsystem") and device.properties["info.subsystem"]=="pci":
  340.             if device.properties.has_key("info.product"):
  341.                 product.set_label("%s"%device.properties["info.product"])
  342.             elif device.properties.has_key("pci.product"):
  343.                 product.set_label("%s"%device.properties["pci.product"])
  344.             elif device.properties.has_key("pci.product_id"):
  345.                 product.set_label("Unknown (0x%x)"%device.properties["pci.product_id"])
  346.             else:
  347.                 product.set_label("Unknown")
  348.  
  349.             if device.properties.has_key("info.vendor"):
  350.                 vendor.set_label("%s"%device.properties["info.vendor"])
  351.             elif device.properties.has_key("pci.vendor"):
  352.                 vendor.set_label("%s"%device.properties["pci.vendor"])
  353.             elif device.properties.has_key("pci.vendor_id"):
  354.                 vendor.set_label("Unknown (0x%x)"%device.properties["pci.vendor_id"])
  355.             else:
  356.                 vendor.set_label("Unknown")
  357.         elif device.properties.has_key("info.subsystem") and device.properties["info.subsystem"]=="block":
  358.             if device.properties.has_key("info.product"):
  359.                 product.set_label("%s"%device.properties["info.product"])
  360.             else:
  361.                 product.set_label("Unknown")
  362.  
  363.             if device.properties.has_key("info.vendor"):
  364.                 vendor.set_label("%s"%device.properties["info.vendor"])
  365.             else:
  366.                 vendor.set_label("Unknown")
  367.         else:
  368.             product.set_label("Unknown")
  369.             vendor.set_label("Unknown")
  370.  
  371.         # clear category, capabilities
  372.         # set category, capabilities
  373.         if device.properties.has_key("info.category"):
  374.             category.set_label('"' + '", "'.join(device.properties["info.capabilities"]) + '"')
  375.         else:
  376.         category.set_label("Unknown")
  377.  
  378.     if device.properties.has_key("info.capabilities"):
  379.             capabilities.set_label(", ".join(device.properties["info.capabilities"]))
  380.     else:
  381.         capabilities.set_label("Unknown")
  382.  
  383.     def update_tab_usb(self, device):
  384.         """Updates the 'USB' tab given a Device object; may hide it"""
  385.         page = self.xml.get_widget("device_notebook").get_nth_page(1)
  386.         if not device.properties.has_key("info.subsystem") or device.properties["info.subsystem"]!="usb":
  387.             page.hide_all()
  388.             return
  389.  
  390.         page.show_all()
  391.  
  392.         version = self.xml.get_widget("ns_usb_version")
  393.         bandwidth = self.xml.get_widget("ns_usb_bandwidth")
  394.         maxpower = self.xml.get_widget("ns_usb_maxpower")
  395.         man_id = self.xml.get_widget("ns_usb_man_id")
  396.         prod_id = self.xml.get_widget("ns_usb_prod_id")
  397.         revision = self.xml.get_widget("ns_usb_rev")
  398.  
  399.         bcdVersion = device.properties["usb.version_bcd"]
  400.         version.set_label("%x.%x"%(bcdVersion>>8, bcdVersion&0xff))
  401.  
  402.         bcdSpeed = device.properties["usb.speed_bcd"]
  403.         bandwidth.set_label("%x.%x Mbit/s"%(bcdSpeed>>8, bcdSpeed&0xff))
  404.         maxpower.set_label("%d mA"%(device.properties["usb.max_power"]))
  405.         if not device.properties.has_key("usb.vendor"):
  406.             man_id.set_label("0x%04x"%(device.properties["usb.vendor_id"]))
  407.         else:
  408.             man_id.set_label("%s"%(device.properties["usb.vendor"]))
  409.         if not device.properties.has_key("usb.product"):
  410.             prod_id.set_label("0x%04x"%(device.properties["usb.product_id"]))
  411.         else:
  412.             prod_id.set_label("%s"%(device.properties["usb.product"]))
  413.         bcdDevice = device.properties["usb.device_revision_bcd"]
  414.         revision.set_label("%x.%x"%((bcdDevice>>8), bcdDevice&0xff))
  415.  
  416.  
  417.     def update_tab_pci(self, device):
  418.         """Updates the 'PCI' tab given a Device object; may hide it"""
  419.         page = self.xml.get_widget("device_notebook").get_nth_page(2)
  420.         if not device.properties.has_key("info.subsystem") or device.properties["info.subsystem"]!="pci":
  421.             page.hide_all()
  422.             return
  423.  
  424.         page.show_all()
  425.  
  426.         man_id = self.xml.get_widget("ns_pci_man_id")
  427.         prod_id = self.xml.get_widget("ns_pci_prod_id")
  428.         subsys_man_id = self.xml.get_widget("ns_pci_subsys_man_id")
  429.         subsys_prod_id = self.xml.get_widget("ns_pci_subsys_prod_id")
  430.  
  431.         if not device.properties.has_key("pci.vendor"):
  432.             man_id.set_label("Unknown (0x%04x)"%(device.properties["pci.vendor_id"]))
  433.         else:
  434.             man_id.set_label("%s"%(device.properties["pci.vendor"]))
  435.         if not device.properties.has_key("pci.product"):
  436.             prod_id.set_label("Unknown (0x%04x)"%(device.properties["pci.product_id"]))
  437.         else:
  438.             prod_id.set_label("%s"%(device.properties["pci.product"]))
  439.  
  440.         if not device.properties.has_key("pci.subsys_vendor"):
  441.             subsys_man_id.set_label("Unknown (0x%04x)"%(device.properties["pci.subsys_vendor_id"]))
  442.         else:
  443.             subsys_man_id.set_label("%s"%(device.properties["pci.subsys_vendor"]))
  444.         if not device.properties.has_key("pci.subsys_product"):
  445.             subsys_prod_id.set_label("Unknown (0x%04x)"%(device.properties["pci.subsys_product_id"]))
  446.         else:
  447.             subsys_prod_id.set_label("%s"%(device.properties["pci.subsys_product"]))
  448.  
  449.     def update_tab_advanced(self, device):
  450.         """Updates the 'Advanced' tab given a Device object"""
  451.         store = gtk.ListStore(gobject.TYPE_STRING,
  452.                               gobject.TYPE_STRING,
  453.                               gobject.TYPE_STRING)
  454.         keys = device.properties.keys()
  455.         keys.sort()
  456.         for p in keys:
  457.             iter = store.append()
  458.             val = device.properties[p]
  459.             ptype = type(val)
  460.             if issubclass(ptype, str):
  461.                 store.set(iter, 0, p, 1, "string", 2, "%s"%val)
  462.             elif issubclass(ptype, unicode):
  463.                 store.set(iter, 0, p, 1, "string", 2, val.encode('utf-8'))
  464.             elif issubclass(ptype, (bool, dbus.Boolean)):
  465.                 if val:
  466.                     store.set(iter, 0, p, 1, "bool", 2, "true")
  467.                 else:
  468.                     store.set(iter, 0, p, 1, "bool", 2, "false")
  469.             elif issubclass(ptype, int):
  470.                 store.set(iter, 0, p, 1, "int", 2, "%d (0x%x)"%(val, val))
  471.             elif issubclass(ptype, long):
  472.                 store.set(iter, 0, p, 1, "long", 2, "%d (0x%x)"%(val, val))
  473.             elif issubclass(ptype, float):
  474.                 store.set(iter, 0, p, 1, "float", 2, "%f"%val)
  475.         elif ptype==list:
  476.         store.set(iter, 0, p, 1, "list", 2, ", ".join(val))
  477.             elif issubclass(ptype, list):
  478.                 # assume strlist
  479.                 formatted = (u'"' + u'", "'.join(val) + u'"').encode('utf-8')
  480.                 store.set(iter, 0, p, 1, "strlist", 2, formatted)
  481.             else:
  482.                 # should never happen
  483.                 store.set(iter, 0, p, 1, "(unknown type)", 2, "")
  484.  
  485.  
  486.         prop_tree_view = self.xml.get_widget("ns_adv_properties")
  487.  
  488.         # remove old columns, if any
  489.         cols = prop_tree_view.get_columns()
  490.         for cr in cols:
  491.             prop_tree_view.remove_column(cr)
  492.         
  493.         cell_renderer = gtk.CellRendererText()
  494.         cell_renderer.set_property("editable", True)
  495.         
  496.         column0 = gtk.TreeViewColumn("Key", cell_renderer, text=0)
  497.         column1 = gtk.TreeViewColumn("Type", cell_renderer, text=1)
  498.         column2 = gtk.TreeViewColumn("Value", cell_renderer, text=2)
  499.         prop_tree_view.append_column(column0)
  500.         prop_tree_view.append_column(column1)
  501.         prop_tree_view.append_column(column2)
  502.  
  503.         prop_tree_view.set_model(store)
  504.  
  505.  
  506.     def update_device_notebook(self, device):
  507.         """Updates the entire notebook of tabs given a Device object"""
  508.         self.update_tab_device(device)
  509.         self.update_tab_advanced(device)
  510.         self.update_tab_usb(device)
  511.         self.update_tab_pci(device)
  512.